Do we need to call the returned function here?

I am not so familiar with defining decorators. But don't we still need this to return the retry version of the inner function?

The decorator should return a function, that's why I tend to think the final () are not needed, but I haven't tested.

If we omit the trailing (), the decorator would return the wrapped function object instead of the function’s result.

Ok, then shouldn't the return type of rate_limit_handler by Any instead of F?

but doesn't using F preserve more type safety since at least at call sites the method has the same type as it has before decoration?

It would if we were returning a function, but based on the above discussion I understood that we're returning the result of the method? Also, what happens when removing the type ignore comment?

The inner function and the wrapper are returning the result of the original function, but the decorator is returning a function.
I am following the below pattern:

def my_decorator(func: Callable) -> Callable:
    def wrapper(*args, **kwargs) -> Any:
        def inner(): -> Any
            print("Inner function logic")
            return func(*args, **kwargs)
        return inner()
    return wrapper

• my_decorator: takes a function func and returns a new function (wrapper)
• wrapper: actual replacement for func. It takes arguments, defines an inner function, and returns the result of inner().
• inner: helper inside wrapper that encapsulates additional logic, then calls and returns the result of func.

obviously mypy will complain about incompatible return types, thus type ignore is added. Otherwise your suggestion of changing return type of the decorator to Any will pass the mypy checks but the thing here is that the decorator could be misused afterwards.

I don't mind changing it, but I'd like to understand what's the best solution in this case or am I following the wrong pattern?